Reorganize snap protocol code for better maintainability:

- Split rlpx/snap.rs into rlpx/snap/ directory:
  - codec.rs: RLP encoding/decoding for snap messages
  - messages.rs: Snap protocol message types
  - mod.rs: Module re-exports

- Split snap.rs into snap/ directory:
  - constants.rs: Snap sync constants and configuration
  - server.rs: Snap protocol server implementation
  - mod.rs: Module re-exports

- Move snap server tests to dedicated tests/ directory
- Update imports in p2p.rs, peer_handler.rs, and code_collector.rs

Document the phased approach for reorganizing snap sync code:
- Phase 1: rlpx/snap module split
- Phase 2: snap module split with server extraction
- Phase 3: healing module unification

Split the large sync.rs (1631 lines) into focused modules:

- sync/full.rs (~260 lines): Full sync implementation
  - sync_cycle_full(), add_blocks_in_batch(), add_blocks()

- sync/snap_sync.rs (~1100 lines): Snap sync implementation
  - sync_cycle_snap(), snap_sync(), SnapBlockSyncState
  - store_block_bodies(), update_pivot(), block_is_stale()
  - validate_state_root(), validate_storage_root(), validate_bytecodes()
  - insert_accounts(), insert_storages() (both rocksdb and non-rocksdb)

- sync.rs (~285 lines): Orchestration layer
  - Syncer struct with start_sync() and sync_cycle()
  - SyncMode, SyncError, AccountStorageRoots types
  - Re-exports for public API

…p/client.rs

Move all snap protocol client-side request methods from peer_handler.rs
to a dedicated snap/client.rs module:
- request_account_range and request_account_range_worker
- request_bytecodes
- request_storage_ranges and request_storage_ranges_worker
- request_state_trienodes
- request_storage_trienodes

Also moves related types: DumpError, RequestMetadata, SnapClientError,
RequestStateTrieNodesError, RequestStorageTrieNodes.

This reduces peer_handler.rs from 2,060 to 670 lines (~68% reduction),
leaving it focused on ETH protocol methods (block headers/bodies).

Added SnapClientError variant to SyncError for proper error handling.
Updated plan_snap_sync.md to mark Phase 4 as complete.

…napError type

Implement Phase 5 of snap sync refactoring plan - Error Handling.

- Create snap/error.rs with unified SnapError enum covering all snap protocol errors
- Update server functions (process_account_range_request, process_storage_ranges_request,
  process_byte_codes_request, process_trie_nodes_request) to return Result<T, SnapError>
- Remove SnapClientError and RequestStateTrieNodesError, consolidate into SnapError
- Keep RequestStorageTrieNodesError struct for request ID tracking in storage healing
- Add From<SnapError> for PeerConnectionError to support error propagation in message handlers
- Update sync module to use SyncError::Snap variant
- Update healing modules (state.rs, storage.rs) to use new error types
- Move DumpError struct to error.rs module
- Update test return types to use SnapError
- Mark Phase 5 as completed in plan document

All phases of the snap sync refactoring are now complete.

Change missing_children_count from u64 to usize in HealingQueueEntry
and node_missing_children function to match StorageHealingQueueEntry
and be consistent with memory structure counting conventions.

Resolve conflicts from #5977 and #6018 merge to main:
- Keep modular sync structure (sync.rs delegates to full.rs and snap_sync.rs)
- Keep snap client code in snap/client.rs (removed from peer_handler.rs)
- Add InsertingAccountRanges metric from #6018 to snap_sync.rs
- Remove unused info import from peer_handler.rs

Previously, sync_cycle_snap() downloaded ALL block headers before starting
state download. This caused unnecessary delays since state download is
independent of header download and the pivot selection only needs recent
headers.

This change moves header downloading to a background task that runs in
parallel with state download:

- Add header_receiver and download_complete fields to SnapBlockSyncState
- Create download_headers_background() function that runs header download
  in a separate tokio task and sends headers through an mpsc channel
- Modify sync_cycle_snap() to spawn the background task and start state
  download immediately
- Add process_pending_headers() helper to incrementally process headers
  at strategic points during snap_sync()
- snap_sync() waits for initial headers only when needed for pivot selection

This allows state download to begin much sooner, potentially reducing
overall sync time significantly for mainnet syncs.

in the multisync monitoring script (docker_monitor.py).

The sync completion logs already contain per-phase completion markers
(e.g. "✓ BLOCK HEADERS complete: 25,693,009 headers in 0:29:00")
but this data was not surfaced in the Slack messages or run summaries.

This adds a parse_phase_timings() function that reads saved container
logs and extracts timing, count, and duration for all 8 snap sync
phases: Block Headers, Account Ranges, Account Insertion, Storage
Ranges, Storage Insertion, State Healing, Storage Healing, and
Bytecodes. The breakdown is appended to both the Slack notification
(as a code block per network instance) and the text-based run log
(run_history.log and per-run summary.txt). When a phase did not
complete (e.g. on a failed run), it is simply omitted from the
breakdown.

proof conversion helpers (encodable_to_proof, proof_to_encodable) from
server.rs to mod.rs since they are shared utilities used by both client
and server.

peer selection, extract magic numbers into named constants
(ACCOUNT_RANGE_CHUNK_COUNT, STORAGE_BATCH_SIZE, HASH_MAX), remove unused
contents field from DumpError and use derive Debug, rename
missing_children to pending_children in healing code, and wrap
process_byte_codes_request in spawn_blocking for consistency with other
server handlers.

…functions

so they no longer depend on the PeerHandler type as a method receiver. The three
methods that used self (request_account_range, request_bytecodes,
request_storage_ranges) now take peers: &mut PeerHandler as a parameter, and the
two already-static methods (request_state_trienodes, request_storage_trienodes)
simply move out of the impl block. Callers in snap_sync.rs, healing/state.rs,
and healing/storage.rs are updated accordingly.

…ation' into feature/background-header-download

…header-download

…ng bug

The block_hashes field stored hashes without block numbers, so the
numbers_and_hashes construction for forkchoice_update inferred block
numbers from position (pivot_header.number - i). When background header
download and update_pivot interleaved inserts, entries ended up out of
order, causing forkchoice_update to write wrong canonical hashes.

BTreeMap keyed by block number naturally handles ordering and deduplicates
overlapping ranges from update_pivot re-inserting the same block numbers.

Resolves conflicts in CHANGELOG.md and crates/networking/p2p/sync/snap_sync.rs,
and addresses the unresolved review feedback in the same commit:

- Completion guard: download_complete is now flipped via Drop, so every return
  path (including ? propagation) signals the main task. Resolves comment #6059
  on download_headers_background error paths.

- Background task no longer calls sync_cycle_full; it sets snap_enabled=false
  and returns. Syncer::sync_cycle picks up the full-sync transition on the next
  cycle. Eliminates the Store/peer concurrency between snap_sync (main) and
  full_sync (background). Resolves the Copilot review on line 297.

- Headers are persisted to the store as each batch arrives, restoring reorg
  detection and checkpoint-resume semantics that the original sequential path
  provided. Resolves the Copilot review on line 236 and the ElFantasma review
  on line 247.

- current_head is tracked as a hash locally in the background loop (mirrors
  the original walk-back-via-parent_hash behaviour for the reorg case).

- The sender strips the duplicate first header from each batch; receivers no
  longer skip(1). Resolves the ElFantasma contract review on line 304.

- Channel buffer extracted to HEADER_CHANNEL_BUFFER. Resolves the greptile
  buffer-size review.

- Grammar fix in snap_server_tests.rs. Resolves the Copilot grammar nit.